Erre a kérdésre már itt vannak válaszok:
Nincs implicit konverzió a túlterhelt operátorban
(2 válasz)
7 éve zárva.
Egy egyszerű csomagolást írok egy elemi típushoz, és megpróbálom elkerülni, hogy túl sokféle operátort kelljen írnom. Reméltem, hogy az implicit típusú konverzió segít, de nem. Itt egy lecsupaszított példa:
struct Int
{
int _i;
Int (int i = 0): _i {i} {}
Int operátor + (const Int & rhs) {return _i + rhs._i;}
};
int main (int argc, char * argv [])
{
(érvénytelen) (Int (1) + 2); // Bírság
(érvénytelen) (2 + Int (1)); // hiba: érvénytelen operandusok a bináris kifejezéshez ('int' és 'Int')
}
Llvm-et használok. A fő első sora rendben van. A második hibát okoz. Azt reméltem, hogy a második sorban megtörténik, hogy a 2-t implicit módon konvertálják Int-re (2), majd hívást kap a + operátor. Miért nem történik meg ez? Miért történik az implicit konverzió az első sorban?
2021-03-01 08:17:34
Az első sorban történik, mert az egyetlen elérhető operátor + operátor + (Int &) (amelynek implicit első paramétere Int ehhez a példányhoz). A második sor meghiúsul, mert az első paraméter egy int, és fogalma sincs arról, hogy a művelet megkísérlése előtt meg kellene konvertálnia (nem tudja, hogy az Int :: operátor + -t kell használnia).
Ezt a problémát elkerülheti, ha az operátort nem tagbarát funkcióvá teszi (http://ideone.com/YCf7wX)
struct Int
{
int _i;
Int (int i = 0): _i {i} {}
barát Int operátor + (const Int & lhs, const Int & rhs);
};
Int operátor + (const Int & lhs, const Int & rhs)
{
visszatérés lhs._i + rhs._i;
}
int main ()
{
Int i;
i + 5;
5 + i;
visszatér 0;
}
|
Nem a keresett válasz? Böngésszen a c ++ operátor-kulcsszó implicit-konverzió címkével ellátott többi kérdésben, vagy tegye fel saját kérdését.